The 8086/8 instruction set, Compiled by Randall A. Nagy;
========================================================

AAA    ASCII adjust for addition.
AAD    ASCII adjust for division.
AAM    ASCII adjust for multiplication.
AAS    ASCII adjust for subtraction.
ADC    ADD with carry.
ADD    Addition.
AND    Bitwise AND.
CALL   Perform Subroutine.
CBW    Convert byte to word.
CLC    Clear Carry Flag.
CLD    Clear Direction Flag.
CLI    Clear Interrupt Plag. 
CMC    Complement Carry Flag.
CMP    Arithmetic Compare.
CMPSB  Compare String, Byte.  
CMPS   Compare String, Word.
CWD    Convert word to double-word.
DAA    Decimal Adjust for Additon.
DAS    Decimal Adjust for Subtraction.
DEC    Decrement.
DIV    Divide.
ESC    Co-processor escape into CPU.
HLT    HALT.
IDIV   Integer Divide.
IMUL   Integer Multiply.
IN     Input from port.
INC    Increment.
INT    Interrupt.
INTO   Interrupt on Overflow (flag = OF).
IRET   Interupt Return.
JA     Jump if Above           (CF and ZF are reset)      == JNBE.
JAE    Jump if Above or Equal  (CF is reset)              == JNB.
JB     Jump if Below           (CF is Set)                == JC, JNE.
JBE    Jump if Bleow or Equal  (CF or ZF are set)         == JNA.
JC     Jump on Carry           (CF is set)                == JB, JNAE.
JCXZ   Jump if CX is Zero.
JE     Jump if Equal           (ZF is set)                == JZ.
JG     Jump if Greater         ((SF = OF) or ZF is reset) == JNLE.
JGE    Jump if GT or Equal     (SF = OF)                  == JNL.
JL     Jump if LT              (SF != OF)                 == JNGE.
JLE    Jump if LT or Equal     (SF != OF) or (ZF set)     == JNG.
JMP    Jump. 
JNA    Jump if Not Above       (CF or ZF is set)          == JBE.
JNAE   Jump if Not Above or =  (CF set)                   == JB, JC.
JNB    Jump if Not Below       (CF is clear)              == JNC.
JNBE   Jump if Not Below or =  (CF and ZF clear)          == JA.
JNE    Jump if Not Equal       (ZF clear)                 == JNZ.
JNG    Jump if Not Greater     (SF != OF) or ZF is set    == JLE.
JNGE   Jump if Not Greater or =(SF != OF)                 == JL.
JNL    Jump if Not Less        (SF = OF)                  == JGE.
JNLE   Jump if Not Less or =   (SF = OF) or ZF is clear   == JG.
JNO    Jump if No Overflow     (OV reset).
JNP    Jump on No Parity       (PF reset)                 == JPO.
JNS    Jump on No Sign         (SF is clear).
JNZ    Jump if Not Zero        (ZF set)                   == JNE.
JO     Jump on Overflow        (OF set).
JP     Jump on Parity          (PF set)                   == JPE.
JPE    Jump on Parity Even     (PF set)                   == JP.
JPO    Jump on Parity Odd      (PF reset)                 == JNP.
JS     Jump on Sign            (SF set).
JZ     Jump on Zero            (ZF set)                   == JE.
LAHF   Load AH with FLAGS.
LDS    Load DS.
LEA    Load Effective Address.
LES    Load ES register.
LOCK   LOCK bus for next instruction.
LODSB  Load Byte form String into AL.
LODSW  Load Word form String into AX.
LOOP   CX based loop.
LOOPE  CX & ZF  based loop if equal.
LOOPNE CX & ZF  based loop if Not Equal.
LOOPNZ CX & ZF  based loop if Zero.
LOOPZ  CX & ZF  based loop while Zero.
MOV    Move Contents.
MOVS   Move String using SI and DI.
MUL    Multiply.
NEG    Negate (2s complement).
NOP    No Operand.
NOT    Logical NOT.
OR     Logical OR.
OUT    AL or AX out to port.
POP    POP stack to operand.
POPF   POP stack to FLAGS.
PUSH   PUSH operand to stack.
PUSHF  PUSH flags to stack.
RCL    Rotate operand left through CF.
RCR    Rotate operand right through CF.
REP    REPEAT string instructions while CX.
RET    RETURN from CALLED subroutine (POP from STACK).
ROL    Rotate Operand Left.
ROR    Rotate Operand Right.
SAHF   Store AH into FLAGS.
SAL    Arithmatic Shift Left.
SAR    Arithmatic Shift Right.
SBB    Subtract with Borrow.
SCASB  Scan String for Byte (using CX).
SCASW  Scan String for Word (using CX).
SHL    Shift Operand Left.
SHR    Shift Operand Right.
STC    Set CF.
STD    Set DF (direction Flag).
STI    Set Interrupt Flag (enable maskable interrupts).
STOSB  Copy AL to contents of DI.
STOSW  Copy AX to contents of DI.
SUB    Subtract.
TEST   AND operands, FLAGS only.
WAIT   Wait for external interrupt.
XCHG   Swap contents of two operands.
XLAT   Swap using 256-byte table pionted to by BX.
XOR    Logical XOR.